home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / vol_100 / 150_01 / roff1.c < prev    next >
Text File  |  1985-09-05  |  13KB  |  478 lines
  1. /*
  2.        HEADER:  150.??;
  3.         TITLE:  ROFF - "RUNOFF" Text Formatter Program;
  4.       VERSION:  5.1;
  5.          DATE:  08/28/1982;
  6.   DESCRIPTION:  "A Text formatter based upon the one in Kernighan and Plauger's
  7.                  book SOFTWARE TOOLS.  Contains provisions for right justifi-
  8.                  cation, page headings and footings, variable margins, inden-
  9.                  tation, page numbers in header text, centered text, underlin-
  10.                  ing, and page lengths.  Easy to use.  Processes plain ASCII
  11.                  text from almost any editor, and formats it to to drive most  
  12.                  printers in straightforward fashion.  No provisions for fancy
  13.                  fonts, proportional spacing, etc.  DOC file contains good but 
  14.                  brief tutorial; sufficient for most semi-experienced users.";
  15.      KEYWORDS:  ROFF, Text Formatter, Software Tools;
  16.        SYSTEM:  any system with C compiler;
  17.      FILENAME:  ROFF1.C;
  18.      SEE-ALSO:  ROFF.DOC, ROFF.H, ROFF.HE, ROFF2.C, ROFF.EXE;
  19.       AUTHORS:  modified "for IBM-PC" by M. S. Zachmann;
  20.     COMPILERS:  BDS-C originally, IBM C compiler unknown;
  21.    REFERENCES:  AUTHORS: M. S. Zachmann; TITLE: "ROFF";
  22.                 CITATION: "PC-SIG Disk 50 or 142";
  23.                 AUTHORS: Kernighan and Plauger; TITLE: "Software Tools";
  24.                 CITATION: "available in many computer stores" 
  25.        ENDREF;
  26. */
  27. #define FALSE 0
  28. #define TRUE 1
  29.  
  30. /* 7 MAY 81 */
  31. /* based on the formatter presented in Kernighan and Plauger's
  32. SOFTWARE TOOLS, modified for BDS C */
  33.  
  34.  
  35.  
  36. #include "stdio.h"
  37. #include "ctype.h"
  38. #include "ROFF.H"
  39.  
  40.  
  41. main(argc, argv)
  42. int argc;
  43. char **argv;
  44. {
  45.    char filename[20];
  46.    char line[MAXLINE];
  47.    struct _iobuf *bufr;
  48.  
  49.  
  50.     errprnt("\nVersion 5.1\n");
  51.  
  52.     debug = FALSE;
  53.     if (argc == 1)
  54.     { errprnt("\nUSAGE:  roff >destination origin_file \n");
  55.       errprnt("Where origin_file is any valid text file name\n");
  56.       errprnt("And destination is a filename, or LST: (printer)\n");
  57.       errprnt("\tor left out (to console)\n");
  58.         exit();
  59.     }
  60.  
  61.     argv++;
  62.     while ( --argc > 0 )
  63.     { strcpy (filename, *argv++);        /* get next argument */
  64.         errprnt("\nNow processing <%s>",filename );
  65.         if (filename[0] == '-' && filename[1]=='d')
  66.         {
  67.             debug=TRUE;
  68.             continue;
  69.         }
  70.  
  71.  
  72.         if ((bufr = fopen(filename, "r")) == NULL)
  73.         { errprnt("\ncan not open <%s>", filename );
  74.             continue;
  75.         }
  76.  
  77.         init_defaults();
  78.  
  79.         while ( fgets( line,MAXLINE, bufr ) != 0 ) /*until EOF or CPMEOF */
  80.         { if (line[0] == COMMAND )
  81.                 comand (line);
  82.             else
  83.                 text (line);
  84.  
  85.         }
  86.         if (LINENO > 0  || OUTBUF[0] !='\0')
  87.             space (HUGE);        /* flush last output */
  88.         errprnt("\nDone processing <%s>", filename );
  89.  
  90.     }     /* end while (--argc > 0 ) */
  91.     exit(0);
  92. }        /* end main()           */
  93.  
  94.  
  95. /********************************************************************
  96. initializes the global variables governing the execution of the
  97.  format commands.
  98. ********************************************************************/
  99. init_defaults()
  100. {
  101.  
  102.     FILL = FI_DEF;    /* yes we want filled lines */
  103.     LSVAL = LS_DEF;    /* line spacing = 1 */
  104.     INVAL = IN_DEF;    /* left margin indent  0 */
  105.     RMVAL = RM_DEF;    /* right margin = page width  */
  106.     TIVAL = TI_DEF;    /* left margin temporary indent    0 */
  107.     CEVAL = CE_DEF;    /* next n lines to be centered -  0  */
  108.     ULVAL = UL_DEF;    /* next n lines to be underlined -  0  */
  109.  
  110.     PAGESTOP = FALSE;
  111.     PLVAL = PAGELEN;
  112.     M1VAL = M1_DEF;        /* top and bottom margins */
  113.     M2VAL = M2_DEF;
  114.     M3VAL = M3_DEF;
  115.     M4VAL = M4_DEF;
  116.     CURPAG = 0;
  117.     NEWPAG = 1;
  118.     LINENO = 0;
  119.     BOTTOM = PLVAL - M3VAL - M4VAL;
  120.  
  121.     OUTWRDS = 0;    /* no. of words in outbuf */
  122.     OUTBUF [0] = '\0';
  123.     DIR = 0;
  124.  
  125.     strcpy ( HEADER, "\n" );
  126.     strcpy ( FOOTER, "\n" );
  127. }
  128.  
  129.  
  130. /*****************************************************************
  131. this function decodes the command type, returning the type, or
  132.     UNKNOWN.
  133. *******************************************************************/
  134. int comtyp (line)
  135. char *line;
  136. {
  137.     char let1, let2;
  138.  
  139.     let1 = toupper( line[1] );
  140.     let2 = toupper( line[2] );
  141.  
  142.     if ( let1=='F' && let2=='I')    return( FI );
  143.     if ( let1=='F' && let2=='O')    return( FO );
  144.     if ( let1=='T' && let2=='I')    return( TI );
  145.     if ( let1=='B' && let2=='P')    return( BP );
  146.     if ( let1=='B' && let2=='R')    return( BR );
  147.     if ( let1=='C' && let2=='E')    return( CE );
  148.     if ( let1=='H' && let2=='E')    return( HE );
  149.     if ( let1=='I' && let2=='N')    return( IN );
  150.     if ( let1=='L' && let2=='S')    return( LS );
  151.     if ( let1=='N' && let2=='F')    return( NF );
  152.     if ( let1=='P' && let2=='L')    return( PL );
  153.     if ( let1=='R' && let2=='M')    return( RM );
  154.     if ( let1=='S' && let2=='P')    return( SP );
  155.     if ( let1=='U' && let2=='L')    return( UL );
  156.     if ( let1=='M')
  157.     { if (let2=='1')        return( M1 );
  158.         if (let2=='2')        return( M2 );
  159.         if (let2=='3')        return( M3 );
  160.         if (let2=='4')        return( M4 );
  161.     }
  162.  
  163.     return( UNKNOWN );        /* no match */
  164.  
  165. }
  166.  
  167.  
  168. /*********************************************************************
  169. Skips white-space characters at the beginning of a string.
  170. *********************************************************************/
  171. skip_blanks ( string )
  172. char *string;
  173. {
  174.     char local[ MAXLINE ];
  175.     int i, j, k;
  176.  
  177.  
  178.  
  179.     strcpy ( local, string );
  180.  
  181.     for (i=0; local[i]==' ' || local[i]=='\t' || local[i]=='\n' ; i++);
  182.  
  183.     for (j=0; (string[j]=local[i]) != '\0' ; i++, j++ )    ;
  184.  
  185.     return;
  186. }
  187.  
  188.  
  189. /*********************************************************************
  190.  
  191. Truncates white-space characters at the end of a string.
  192.  
  193. *********************************************************************/
  194. trunc_bl (string)
  195. char *string;
  196. {
  197.     char *ptr;
  198.     int k;
  199.  
  200.     k = strlen (string);
  201.     ptr = &string[ k-1 ];    /* char before terminating nul */
  202.  
  203.     while (*ptr==BLANK || *ptr==TAB || *ptr==NEWLINE)    
  204.         *ptr--  = '\0';
  205. }
  206.  
  207.  
  208. /*******************************************************************
  209. performs the formatting command returned by comtyp - sets global
  210.   variables ( indenting, underlining, etc. )
  211. *******************************************************************/
  212.  
  213. comand ( line )
  214. char *line;
  215. {
  216.     int c_type;    /* command type  */
  217.     int arg_val;    /* argument value, if any */
  218.     char arg_typ;    /* relative (+ or -) or absolute */
  219.     int i;
  220.  
  221.     c_type = comtyp (line);
  222.     if DEBUG errprnt("\n\nCOMAND %d",c_type);
  223.  
  224.     if (c_type == UNKNOWN)    /* IGNORE ALIEN ORDERS */
  225.     {
  226.         errprnt( "UNKNOWN COMMAND: <%s>\n", line);
  227.         return;
  228.     }
  229.  
  230.     arg_val = get_val ( line, &arg_typ );
  231.     if DEBUG errprnt( " \n    get_val returned arg_val=%d, arg_typ= %c   ",
  232.       arg_val,    arg_typ   );
  233.     if DEBUG errprnt("\n\n");
  234.  
  235.     switch (c_type)
  236.     {
  237.     case FI :    /* filled lines  */
  238.         brk();    /* flush out last unfilled */
  239.         FILL = YES;
  240.         break;
  241.  
  242.     case NF :    /* non-filled lines */
  243.         brk();    /* flush out */
  244.         FILL = NO;
  245.         break;    /* down and cry */
  246.  
  247.     case BR :    /* just cause a break */
  248.         brk();
  249.         break;
  250.  
  251.     case LS :    /* set line spacing value */
  252.         set (&LSVAL, arg_val, arg_typ, LS_DEF, 1, HUGE );
  253.         break;
  254.  
  255.     case TI :    /* set temporary left indent */
  256.         brk();
  257.         set ( &TIVAL, arg_val, arg_typ, TI_DEF, 0, RMVAL );
  258.         break;
  259.  
  260.     case IN :    /* set left indent */
  261.         set ( &INVAL, arg_val, arg_typ, IN_DEF, 0, RMVAL-1 );
  262.         TIVAL = INVAL;
  263.         break;
  264.  
  265.     case RM:    /* set right margin */
  266.         set ( &RMVAL, arg_val, arg_typ, RM_DEF, TIVAL+1, HUGE );
  267.         break;
  268.     case M1:    /* set topmost margin */
  269.         set ( &M1VAL, arg_val, arg_typ, M1_DEF, 0, HUGE);
  270.         break;
  271.  
  272.     case M2:    /* set second top margin */
  273.         set ( &M2VAL, arg_val, arg_typ, M2_DEF, 0, HUGE);
  274.         break;
  275.  
  276.     case M3:    /* set first bottom margin */
  277.         set ( &M3VAL, arg_val, arg_typ, M3_DEF, 0, HUGE);
  278.         break;
  279.  
  280.     case M4:    /* set bottom-most margin */
  281.         set ( &M4VAL, arg_val, arg_typ, M4_DEF, 0, HUGE);
  282.         break;
  283.  
  284.     case CE :    /* center next arg_val lines */
  285.         brk();
  286.         set ( &CEVAL, arg_val, arg_typ, CE_DEF, 0, HUGE);
  287.         break;
  288.  
  289.     case UL :    /* underline next arg_val lines */
  290.         set ( &ULVAL, arg_val, arg_typ, UL_DEF, 1, HUGE );
  291.         break;
  292.  
  293.     case HE :    /* get header title for pages */
  294.         gettl ( line, HEADER );
  295.         break;
  296.  
  297.     case FO :    /* get footer title for pages */
  298.         gettl ( line, FOOTER );
  299.         break;